{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 4: Training a spiking neural network on a spiking dataset (Spiking Heidelberg Digits)\n",
    "\n",
    "Manu Srinath Halvagal (https://zenkelab.org/team/) and Friedemann Zenke (https://fzenke.net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more details on surrogate gradient learning, please see: \n",
    "\n",
    "> Neftci, E.O., Mostafa, H., and Zenke, F. (2019). Surrogate Gradient Learning in Spiking Neural Networks: Bringing the Power of Gradient-based optimization to spiking neural networks. IEEE Signal Process Mag 36, 51–63.\n",
    "> https://ieeexplore.ieee.org/document/8891809 and https://arxiv.org/abs/1901.09948\n",
    "\n",
    "> Cramer, B., Stradmann, Y., Schemmel, J., and Zenke, F. (2020). The Heidelberg Spiking Data Sets for the Systematic Evaluation of Spiking Neural Networks. IEEE Transactions on Neural Networks and Learning Systems 1–14. \n",
    "> https://ieeexplore.ieee.org/document/9311226 and https://arxiv.org/abs/1910.07407\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Tutorials 2 and 3, we have seen how to train a multi-layer spiking neural network on the [Fashion MNIST dataset](https://github.com/zalandoresearch/fashion-mnist) along with an activity regularizer. However, the spiking activity input to the network was generated using a simple time-to-first-spike code. Here we apply the model to train a spiking network to learn the Spiking Heidelberg Digits dataset (https://compneuro.net/posts/2019-spiking-heidelberg-digits/). This dataset uses a more sophisticated cochlear model to generate the spike data corresponding to audio recordings of spoken digits (examples below)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Image of Yaktocat](https://compneuro.net/img/hdspikes_digits_samples.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import h5py\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.gridspec import GridSpec\n",
    "import seaborn as sns\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "from torch.utils import data\n",
    "\n",
    "from utils import get_shd_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The coarse network structure and the time steps are dicated by the SHD dataset. \n",
    "nb_inputs  = 700\n",
    "nb_hidden  = 200\n",
    "nb_outputs = 20\n",
    "\n",
    "time_step = 1e-3\n",
    "nb_steps = 100\n",
    "max_time = 1.4\n",
    "\n",
    "batch_size = 256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dtype = torch.float\n",
    "\n",
    "# Check whether a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")     \n",
    "else:\n",
    "    device = torch.device(\"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup of the spiking dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File shd_train.h5.gz decompressed to:\n",
      "/home/zenkfrie/data/hdspikes/shd_train.h5.gz\n",
      "File shd_test.h5.gz decompressed to:\n",
      "/home/zenkfrie/data/hdspikes/shd_test.h5.gz\n"
     ]
    }
   ],
   "source": [
    "# Here we load the Dataset\n",
    "cache_dir = os.path.expanduser(\"~/data\")\n",
    "cache_subdir = \"hdspikes\"\n",
    "get_shd_dataset(cache_dir, cache_subdir)\n",
    "\n",
    "train_file = h5py.File(os.path.join(cache_dir, cache_subdir, 'shd_train.h5'), 'r')\n",
    "test_file = h5py.File(os.path.join(cache_dir, cache_subdir, 'shd_test.h5'), 'r')\n",
    "\n",
    "x_train = train_file['spikes']\n",
    "y_train = train_file['labels']\n",
    "x_test = test_file['spikes']\n",
    "y_test = test_file['labels']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code for learning the SHD dataset is nearly identical to what we have seen for the FashionMNIST dataset in the last two tutorials. An important difference is that, now, we have the input data already in the form of spikes. This is reflected in the sparse_data_generator below. \n",
    "\n",
    "In order to use the data for learning with our spiking network, we also need to discretize the spike times into n_steps bins. Note the additional max_time argument (~1.4 for SHD) that forms the upper limit of the bins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sparse_data_generator_from_hdf5_spikes(X, y, batch_size, nb_steps, nb_units, max_time, shuffle=True):\n",
    "    \"\"\" This generator takes a spike dataset and generates spiking network input as sparse tensors. \n",
    "\n",
    "    Args:\n",
    "        X: The data ( sample x event x 2 ) the last dim holds (time,neuron) tuples\n",
    "        y: The labels\n",
    "    \"\"\"\n",
    "\n",
    "    labels_ = np.array(y,dtype=np.int)\n",
    "    number_of_batches = len(labels_)//batch_size\n",
    "    sample_index = np.arange(len(labels_))\n",
    "\n",
    "    # compute discrete firing times\n",
    "    firing_times = X['times']\n",
    "    units_fired = X['units']\n",
    "    \n",
    "    time_bins = np.linspace(0, max_time, num=nb_steps)\n",
    "\n",
    "    if shuffle:\n",
    "        np.random.shuffle(sample_index)\n",
    "\n",
    "    total_batch_count = 0\n",
    "    counter = 0\n",
    "    while counter<number_of_batches:\n",
    "        batch_index = sample_index[batch_size*counter:batch_size*(counter+1)]\n",
    "\n",
    "        coo = [ [] for i in range(3) ]\n",
    "        for bc,idx in enumerate(batch_index):\n",
    "            times = np.digitize(firing_times[idx], time_bins)\n",
    "            units = units_fired[idx]\n",
    "            batch = [bc for _ in range(len(times))]\n",
    "            \n",
    "            coo[0].extend(batch)\n",
    "            coo[1].extend(times)\n",
    "            coo[2].extend(units)\n",
    "\n",
    "        i = torch.LongTensor(coo).to(device)\n",
    "        v = torch.FloatTensor(np.ones(len(coo[0]))).to(device)\n",
    "    \n",
    "        X_batch = torch.sparse.FloatTensor(i, v, torch.Size([batch_size,nb_steps,nb_units])).to(device)\n",
    "        y_batch = torch.tensor(labels_[batch_index],device=device)\n",
    "\n",
    "        yield X_batch.to(device=device), y_batch.to(device=device)\n",
    "\n",
    "        counter += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup of the spiking network model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tau_mem = 10e-3\n",
    "tau_syn = 5e-3\n",
    "\n",
    "alpha   = float(np.exp(-time_step/tau_syn))\n",
    "beta    = float(np.exp(-time_step/tau_mem))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also now include recurrent weights in the hidden layer. This significantly improves performance on the SHD dataset ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init done\n"
     ]
    }
   ],
   "source": [
    "weight_scale = 0.2\n",
    "\n",
    "w1 = torch.empty((nb_inputs, nb_hidden),  device=device, dtype=dtype, requires_grad=True)\n",
    "torch.nn.init.normal_(w1, mean=0.0, std=weight_scale/np.sqrt(nb_inputs))\n",
    "\n",
    "w2 = torch.empty((nb_hidden, nb_outputs), device=device, dtype=dtype, requires_grad=True)\n",
    "torch.nn.init.normal_(w2, mean=0.0, std=weight_scale/np.sqrt(nb_hidden))\n",
    "\n",
    "v1 = torch.empty((nb_hidden, nb_hidden), device=device, dtype=dtype, requires_grad=True)\n",
    "torch.nn.init.normal_(v1, mean=0.0, std=weight_scale/np.sqrt(nb_hidden))\n",
    "\n",
    "print(\"init done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_voltage_traces(mem, spk=None, dim=(3,5), spike_height=5):\n",
    "    gs=GridSpec(*dim)\n",
    "    if spk is not None:\n",
    "        dat = 1.0*mem\n",
    "        dat[spk>0.0] = spike_height\n",
    "        dat = dat.detach().cpu().numpy()\n",
    "    else:\n",
    "        dat = mem.detach().cpu().numpy()\n",
    "    for i in range(np.prod(dim)):\n",
    "        if i==0: a0=ax=plt.subplot(gs[i])\n",
    "        else: ax=plt.subplot(gs[i],sharey=a0)\n",
    "        ax.plot(dat[i])\n",
    "        ax.axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "def live_plot(loss):\n",
    "    if len(loss) == 1:\n",
    "        return\n",
    "    clear_output(wait=True)\n",
    "    ax = plt.figure(figsize=(3,2), dpi=150).gca()\n",
    "    ax.plot(range(1, len(loss) + 1), loss)\n",
    "    ax.set_xlabel(\"Epoch\")\n",
    "    ax.set_ylabel(\"Loss\")\n",
    "    ax.xaxis.get_major_locator().set_params(integer=True)\n",
    "    sns.despine()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SurrGradSpike(torch.autograd.Function):\n",
    "    \"\"\"\n",
    "    Here we implement our spiking nonlinearity which also implements \n",
    "    the surrogate gradient. By subclassing torch.autograd.Function, \n",
    "    we will be able to use all of PyTorch's autograd functionality.\n",
    "    Here we use the normalized negative part of a fast sigmoid \n",
    "    as this was done in Zenke & Ganguli (2018).\n",
    "    \"\"\"\n",
    "    \n",
    "    scale = 100.0 # controls steepness of surrogate gradient\n",
    "\n",
    "    @staticmethod\n",
    "    def forward(ctx, input):\n",
    "        \"\"\"\n",
    "        In the forward pass we compute a step function of the input Tensor\n",
    "        and return it. ctx is a context object that we use to stash information which \n",
    "        we need to later backpropagate our error signals. To achieve this we use the \n",
    "        ctx.save_for_backward method.\n",
    "        \"\"\"\n",
    "        ctx.save_for_backward(input)\n",
    "        out = torch.zeros_like(input)\n",
    "        out[input > 0] = 1.0\n",
    "        return out\n",
    "\n",
    "    @staticmethod\n",
    "    def backward(ctx, grad_output):\n",
    "        \"\"\"\n",
    "        In the backward pass we receive a Tensor we need to compute the \n",
    "        surrogate gradient of the loss with respect to the input. \n",
    "        Here we use the normalized negative part of a fast sigmoid \n",
    "        as this was done in Zenke & Ganguli (2018).\n",
    "        \"\"\"\n",
    "        input, = ctx.saved_tensors\n",
    "        grad_input = grad_output.clone()\n",
    "        grad = grad_input/(SurrGradSpike.scale*torch.abs(input)+1.0)**2\n",
    "        return grad\n",
    "    \n",
    "# here we overwrite our naive spike function by the \"SurrGradSpike\" nonlinearity which implements a surrogate gradient\n",
    "spike_fn  = SurrGradSpike.apply"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "run_snn is also changed now in order to include the recurrent input in the hidden layer computation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_snn(inputs):\n",
    "    syn = torch.zeros((batch_size,nb_hidden), device=device, dtype=dtype)\n",
    "    mem = torch.zeros((batch_size,nb_hidden), device=device, dtype=dtype)\n",
    "\n",
    "    mem_rec = []\n",
    "    spk_rec = []\n",
    "\n",
    "    # Compute hidden layer activity\n",
    "    out = torch.zeros((batch_size, nb_hidden), device=device, dtype=dtype)\n",
    "    h1_from_input = torch.einsum(\"abc,cd->abd\", (inputs, w1))\n",
    "    for t in range(nb_steps):\n",
    "        h1 = h1_from_input[:,t] + torch.einsum(\"ab,bc->ac\", (out, v1))\n",
    "        mthr = mem-1.0\n",
    "        out = spike_fn(mthr)\n",
    "        rst = out.detach() # We do not want to backprop through the reset\n",
    "\n",
    "        new_syn = alpha*syn +h1\n",
    "        new_mem =(beta*mem +syn)*(1.0-rst)\n",
    "\n",
    "        mem_rec.append(mem)\n",
    "        spk_rec.append(out)\n",
    "        \n",
    "        mem = new_mem\n",
    "        syn = new_syn\n",
    "\n",
    "    mem_rec = torch.stack(mem_rec,dim=1)\n",
    "    spk_rec = torch.stack(spk_rec,dim=1)\n",
    "\n",
    "    # Readout layer\n",
    "    h2= torch.einsum(\"abc,cd->abd\", (spk_rec, w2))\n",
    "    flt = torch.zeros((batch_size,nb_outputs), device=device, dtype=dtype)\n",
    "    out = torch.zeros((batch_size,nb_outputs), device=device, dtype=dtype)\n",
    "    out_rec = [out]\n",
    "    for t in range(nb_steps):\n",
    "        new_flt = alpha*flt +h2[:,t]\n",
    "        new_out = beta*out +flt\n",
    "\n",
    "        flt = new_flt\n",
    "        out = new_out\n",
    "\n",
    "        out_rec.append(out)\n",
    "\n",
    "    out_rec = torch.stack(out_rec,dim=1)\n",
    "    other_recs = [mem_rec, spk_rec]\n",
    "    return out_rec, other_recs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(x_data, y_data, lr=1e-3, nb_epochs=10):\n",
    "    \n",
    "    params = [w1,w2,v1]\n",
    "    optimizer = torch.optim.Adamax(params, lr=lr, betas=(0.9,0.999))\n",
    "\n",
    "    log_softmax_fn = nn.LogSoftmax(dim=1)\n",
    "    loss_fn = nn.NLLLoss()\n",
    "    \n",
    "    loss_hist = []\n",
    "    for e in range(nb_epochs):\n",
    "        local_loss = []\n",
    "        for x_local, y_local in sparse_data_generator_from_hdf5_spikes(x_data, y_data, batch_size, nb_steps, nb_inputs, max_time):\n",
    "            output,recs = run_snn(x_local.to_dense())\n",
    "            _,spks=recs\n",
    "            m,_=torch.max(output,1)\n",
    "            log_p_y = log_softmax_fn(m)\n",
    "            \n",
    "            # Here we set up our regularizer loss\n",
    "            # The strength paramters here are merely a guess and there should be ample room for improvement by\n",
    "            # tuning these paramters.\n",
    "            reg_loss = 2e-6*torch.sum(spks) # L1 loss on total number of spikes\n",
    "            reg_loss += 2e-6*torch.mean(torch.sum(torch.sum(spks,dim=0),dim=0)**2) # L2 loss on spikes per neuron\n",
    "            \n",
    "            # Here we combine supervised loss and the regularizer\n",
    "            loss_val = loss_fn(log_p_y, y_local) + reg_loss\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            loss_val.backward()\n",
    "            optimizer.step()\n",
    "            local_loss.append(loss_val.item())\n",
    "        mean_loss = np.mean(local_loss)\n",
    "        loss_hist.append(mean_loss)\n",
    "        live_plot(loss_hist)\n",
    "        print(\"Epoch %i: loss=%.5f\"%(e+1,mean_loss))\n",
    "        \n",
    "    return loss_hist\n",
    "        \n",
    "        \n",
    "def compute_classification_accuracy(x_data, y_data):\n",
    "    \"\"\" Computes classification accuracy on supplied data in batches. \"\"\"\n",
    "    accs = []\n",
    "    for x_local, y_local in sparse_data_generator_from_hdf5_spikes(x_data, y_data, batch_size, nb_steps, nb_inputs, max_time, shuffle=False):\n",
    "        output,_ = run_snn(x_local.to_dense())\n",
    "        m,_= torch.max(output,1) # max over time\n",
    "        _,am=torch.max(m,1)      # argmax over output units\n",
    "        tmp = np.mean((y_local==am).detach().cpu().numpy()) # compare to labels\n",
    "        accs.append(tmp)\n",
    "    return np.mean(accs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_epochs = 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WARNING: Training for a large number of epochs could take a significant amount of time. Reduce the nb_epochs parameter as necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbYAAAE/CAYAAAAqtuZgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAABcSAAAXEgFnn9JSAAArkElEQVR4nO3deXwc9X3/8ddH9y3ZkmXL94lvMDEYMDehQIAQCCFXmwRyNldzkqbJLwlNyH2UNKVNWggkpWlJCAGCCZBw25iADdjYGN82lm9LsiXrPr6/P2a0XgtJtqWdnd3Z9/Px2MfuzM7sfvbLoLdn5jvfMeccIiIiUZEVdgEiIiKJpGATEZFIUbCJiEikKNhERCRSFGwiIhIpCjYREYkUBZuIiESKgk1ERCJFwSYiIpGiYBMRkUhRsImISKQo2EREJFIUbCIiEikKtgGY2QNm9kDYdYiIyInJCbuAFDZtzpw5cwDd10dEJDksER+iPTYREYkUBZuIiESKgk1ERCJFwSYiIpGiYBMRkUhRsImISKQo2EREJFJ0HVsAfrtiB09v2M+h1k6uPLmGd50+MeySREQyhoItAGt2HuLB1bsBmFFdGnI1IiKZRYciA1BRmBt7fbC1I8RKREQyj4ItAGVxwdbY2hliJSIimUfBFoCKorzY64MtCjYRkWRSsAUg/lDkIe2xiYgklYItAOVF8efYFGwiIsmkYAvAUXtsLZ04pzvfiIgkS9oGm5l93szuNbONZnbIzNrNbLuZ/drM5odZW3lcsHV099DW2RNiNSIimSVtgw34CvAWoB54DFgCtAHvA1aa2ZVhFRbfKxLU5V9EJJnS+QLttwErnXNt8TPN7BPArcBtZjbeOdeV7MIKcrMpzM2mtbMb8DqQ1JQXJrsMEZGMlLZ7bM65ZX1DzZ//78BmYDQwJ+mF+eIPR6rLv4hI8qRtsB1Db5KEdgywokhd/kVEwhC5YDOz9wEzgY3+IxRlfXpGiohIcqTzOTYAzOxGYC5QDMz2X+8C3uOc6w6rLl2kLSISjrQPNuBS4M1x09uB9zvnVh7Pyma2doC3pg2nqIoiDYQsIhKGtD8U6Zy72DlnwAjgPLzDj0+Z2VfDrEudR0REwhGFPTYAnHMHgWfM7HJgOfAtM3vUOffCMdab2998f09uyL0q4wdC1qFIEZHkSfs9tr6cc53A3YABbw2rjnKdYxMRCUXkgs13wH8eFVYBCjYRkXBENdjO9583h1XAUZ1HdI5NRCRp0jLYzOxsM7vMzLL6zM81s0/jjRfZindIMhTaYxMRCUe6dh6ZAdwBHDCzlUAdUAXMB2rwBkO+3jm3I6wCKwqPdB5pbOukp8eRlWVhlSMikjHSNdieAr6Dd8jxZLxQ6wC2AfcA/+qc2xRadRx9s1HnoKmt66h5IiISjLQMNufcViDU69SOpTQ/BzMv1AAaWjoUbCIiSZCW59jSQVaWUVNWEJteu6sxxGpERDKHgi1AZ0ytjL1etvnAIEuKiEiiKNgCtHjakWBbvrkuxEpERDKHgi1AZ8UF29YDzew62BpiNSIimUHBFqDxI4qYVFkUm35We20iIoFTsAVs8bSq2OtnN+k8m4hI0BRsAYs/z/bs5jpcb/9/EREJhIItYPHn2fY0trH1QHOI1YiIRJ+CLWBVJfnMGlMam16m82wiIoFSsCXBWUd1+9d5NhGRICnYkuDsuA4kyzfX0dOj82wiIkFRsCXBoqkj6R3Yv6Glk1d3a3gtEZGgKNiSoKwgl/njK2LTS9XtX0QkMAq2JDl/xpHDkU9v2B9iJSIi0aZgS5LzThoVe/3Ctnqa27tCrEZEJLoUbEmyYEIFpQXe7e86ux3PbVG3fxGRICjYkiQnO4tzph85HPmUDkeKiARCwZZE58cdjtR5NhGRYCjYkij+PNu2uha212l4LRGRRFOwJdHYikJmVJfEprXXJiKSeAq2JIs/HKnzbCIiiadgS7L4w5HPbq6jo6snxGpERKJHwZZki6aMpCDXa/aWjm5WbK8PuSIRkWhRsCVZQW42Z049Mtr/k+t1OFJEJJEUbCG4aFZ17PXDa/bortoiIgmkYAvBJXPGxF6/Xt/Cut1NIVYjIhItCrYQjCkv4NSJFbHph9fuCa8YEZGIUbCF5LK5R/baHlmjYBMRSRQFW0gujQu29Xub2LL/cIjViIhEh4ItJJOripk1pjQ2/cjavSFWIyISHQq2EF0278he28NrdodYiYhIdCjYQhQfbKtqD7HzYGuI1YiIRIOCLUQzR5cypao4Nv2oekeKiAybgi1EZnZUJ5I/rtoVYjUiItGgYAvZlSfXxF6/+PpBNqt3pIjIsCjYQjZ3bNlRvSN/v7I2xGpERNKfgi1kZsY7Fo6PTd/74k66ezR2pIjIUCnYUsDVp44jJ8sA2NPYxtJNB0KuSEQkfSnYUkBVST4Xxo34/7sVO0KsRkQkvSnYUkT84chHX93LoZbOEKsREUlfCrYUcdGsaiqL8wDo6OrhgdXq+i8iMhQKthSRm53F2xaMi03fo96RIiJDomBLIdedduRw5KodB9m4VzcgFRE5UQq2FDK7poy5Y8ti09prExE5cQq2FHNd/DVtL+2kq7snxGpERNKPgi3FXLVgHLnZ3jVt+5vaeWrD/pArEhFJLwq2FDOyOI+LZ4+OTd+xbFt4xYiIpCEFWwp6/1mTY6+XbjrAmp2HwitGRCTNKNhS0JlTR3LK+PLY9C+e3hJiNSIi6UXBloLMjI+dPy02vWT1LnbUt4RYkYhI+lCwpahL545hUmURAD0ObntGe20iIsdDwZaisrOMj5w7NTZ994od1B1uD7EiEZH0oGBLYe9YOD42fmRbZw+/Xr495IpERFJfWgabmRWZ2dVmdruZrTezNjNrNrNVZvZ1MysJu8ZEKMjN5vrFk2PTv16+jZaOrvAKEhFJA2kZbMB7gT8AHwS6gQeAZ4ApwD8DL5hZ9cCrp4/3nTWJorxsABpaOvndCg2zJSIymHQNtk7gP4E5zrk5zrl3OucuA2YCLwGzgFtCrC9hKoryePfpE2PT//XMFg2zJSIyiLQMNufcr5xzH3POreszfzfwSX/y7WaWl/zqEu9D504hO8sbZqu2oZUlr+wOuSIRkdSVlsF2DKv853ygMsxCEmVcRSFXnTI2Nv2Lp7bgnAuxIhGR1BXFYOvtI98J1IdZSCJ99LwjXf9f3d3IMxsPhFiNiEjqimKwfcZ/ftg5d8wLv8xsbX8PYNqx1k2m2TVlXDBzVGz6Z49v1F6biEg/IhVsZnY58CG8vbWvhVxOwv193DBbL2xr4IFVu0KsRkQkNSU82PxrzCaaWXGf+SPM7Htm9qCZ/buZJXSPyMxmAXcBBtzonFt1jFUAcM7N7e8BbE5kfYlw5tRK3jzryFUM316yjqa2zhArEhFJPUHssX0N2IrX5R4AM8sHngNuBC4H/h5YbmY1ifhCMxsHPAyMAH7inPtpIj43FX3jrXPJz/H+s+1raueu514PuSIRkdQSRLBdBGx2zq2Mm/d3wAzgCeBS4F+BKuBzw/0yMxsJPApMAu4Avjjcz0xlEyuL+NA5U2LT975Yq3NtIiJxggi2icDGPvOuAhxwg3Puz865zwIbgLcM54v8obP+BMwB7gU+4jLgr/y7Tp8Qe71x32HW7GwMsRoRkdQSRLCNAA72TpiZAecAq51zO+KWWwVMYIj8w5v3A4uAR4D3OOe6h/p56WRSZTGnTRoRm773JQ2zJSLSK4hg24M3ZmOvhXhh91Sf5Ya8Z2Vm2cD/4h32fAZ4u3OuY6ifl46uedO42OsHXt5FR5eG2RIRgWCC7WVgkT/6fileZxIHPNhnuRnAUPurfwq4xn99APh3M7uzn0fVED8/5V05fyx5fieSuuYOHlytrv8iIgA5AXzmD4Argd/704YXdo/3LmBmo4FT8Pa6hmJE3OtrBlwKbsILvsgpL8rl6gVj+a0/2v9tz2zlmlPH4R35FRHJXAnfY3POPYsXNkuB1/CuLbvKORd/rOw9QBNeF/2hfMdNzjk7jse2Yf6clPahc44eZmv5lroQqxERSQ2BjDzinPujc+58/2Ln9zvnavu8f4tzboRz7n+C+P5MMXNMKefOOHK09Y5l28IrRkQkRURqSK1M9MGzj/TTefy1few51BZiNSIi4QtiSK3RZnaefx4tfv40M/s/M1tjZg+Z2VmJ/u5MdN5Joxg/ohCA7h7H3S/sOMYaIiLRFsQe25fxRhgp751hZmV459yuw7uY+jLgL2Y2I4DvzyjZWcZ7Fh25w/bdL7xOd0/kr1EXERlQEMF2AfCqc25D3LzrgdF4vSBnAp8HCoEvBPD9Gee608aT499he9ehNv786t6QKxIRCU8QwTYO2NJn3hVAF/BZ59xG59wteCOPnB/A92ec6tICLp03JjZ9x7KtIVYjIhKuIIKtFGjpnfBHCTkLWOmci7+m7DVgfADfn5HiO5H8dWs9a3YeCrEaEZHwBBFsu4i7ZQ3eOJElwJN9lssBMmoYrCAtnDSCBRMqYtO3L9Vem4hkpiCCbTlwspl91szmAzfjDan1xz7LzQZ2BvD9GeuDcbezuf/lnWzc2xRiNSIi4Qgi2L4LtAM/xhtK62zgSX9EEgDMbDJe78i/BvD9GevyeWOYOsq7cXmPgx89uj7kikREki+IIbXW4h1+vAtvyKybgav7LHYpXueR+xL9/ZksJzuLL14yMzb9yNq9rNzeEGJFIiLJZxlwX84hMbO1c+bMmbN27dqwSzkhzjmu+rdlvOJ3Hjl5fDn3feJssrI0OLKIpLyE/KHSkFoRY2Z89YrZsenVtYf47QqNRiIimSOwYPOH1vonf/isVf7jITP7ct/htiSxzpxayVWnjI1N/+CR9TS1dYZYkYhI8gQSbGZ2LbAB7/zaZcB8/3EZ8G1gvb+MBOQrl8+mKC8bgPrmDn65dFu4BYmIJEkQgyCfhjd0VjHwB7x7s50KLMDrRHIv3nVtv/GXlQCMKS846qLt/3pmCw3NumxQRKIviD22fwKygeucc+9wzt3vnFvlnFvtnHvAOXcd3mDIuXgDJktAPnLeVMoLcwE43N7Fzx7fFHJFIiLBCyLYzgGedc79YaAF/PeWAecG8P3iKy/M5e/Pnxab/tXybWzQRdsiEnFBBFs58PpxLPc6cbe2kWDccPZkJo4sArz7td30wFp0iYeIRFkQwbYH75zasSzwl5UAFeRm87Ur58Smn91cp5uRikikBRFsjwAzzew7/sj+RzHPzXgDJT8cwPdLHxfPrubCmaNi09968FVer2sZZA0RkfSV8JFHzGw88BIwEu9w42+Bbf7bk/A6jkwG6oA3OedqE1pAgqTryCMD2dvYxiX/8jSHWr3r2c6aWslvPnIGZhqRRERSRmqOPOIH1UXAWrwguxH4N//xJWAKsAa4KFVDLYpGlxXw7WvmxaaXb6njgVW7QqxIRCQYOUF8qHPuFbxb11yA1/OxdxiMXcAzzrkng/heGdyVJ4/lvpd28pd1+wC4eck6LpxVTVlBbsiViYgkTiDB1ssPsCf7e8/MPgiMd859M8ga5GjfeOtcntl4gPauHvY3tfOTRzdw01Vzwy5LRCRhwhwE+SPAN0L8/ow0YWQRn7pwemz618u3sXbXoRArEhFJLI3un4E+ev5UplQduSHpV+59hY6unpCrEhFJDAVbBsrPyeaf4w4/rqo9xDcfjEbvTxERBVuGOu+kUbz79Amx6buee53bntkSYkUiIomhYMtgN101l1PGHxnV7OYl6/j5U5tDrEhEZPgUbBmsIDebn79vIRNGFsbmfe9Pr/Hk+n0hViUiMjwKtgxXU17I3R89i8mVRbF5X7pnte7dJiJpa9jBZmbdQ3kAixJQvyTA2IpCfvG+08jL9jaHfU3tfPW+V3QXABFJS4nYY7NhPCRFzBxTypcumxmbfuiVPdz38s4QKxIRGZphB5tzLmsYjzeM/i/h+eDZUzhramVs+uv3rWV7XXOIFYmInDidY5OYrCzjR+88hdJ8b6S1pvYubrjzBQ61dIZcmYjI8VOwyVHGVRTy3Wvnx6a37G/mY3et0MgkIpI2FGzyBleePJbPXXxSbPq5LfV85Q/qTCIi6UHBJv36hzdP55pTx8Wm71lZy7eXrFO4iUjKU7BJv8yM7107n0WTR8bm3bZ0Kzc9sFbhJiIpTcEmA8rPyeYX71vI3LFlsXm/Wr6d25duDbEqEZHBKdhkUCOK8/jNh8/klAkVsXnfeWgdT7ymYbdEJDUp2OSYyotyuf0DpzGuwhtTssfBP/zvS2zc2xRyZSIib6Rgk+NSVZLPbR84jaI875r6pvYuPvirF1izU3ffFpHUomCT4za7poxb3rUA8wdD21HfytW3LtN93EQkpSjY5IRcMncMX718dmy6q8dx85J1/OiR9eotKSIpQcEmJ+zD507lNx8+I3bODeDfntjEzx7fFGJVIiIeBZsMyeLpVfzhE4s5aXRJbN5P/ryBe1bWhliViIiCTYahuqyA//voWUwdVRybd+M9q7j1iU06LCkioVGwybCMLM7jzusXUVWSB4Bz8MNH1vOVP6yhp0fhJiLJp2CTYZtYWcT/ffRMJlUWxeb97/Ov87nfvkxze1eIlYlIJlKwSUJMry7lvk+czcJJI2Lz7n95F5fe8jTPbakLsTIRyTRpG2xmttDMvmxm95pZrZk5M9OxrxCNKM7j1x9cxOJpR+7CXdvQyt/e9ld+8dRmnXcTkaRI22ADvgZ8F7gGGHeMZSVJivNzuOOG0/mHi6aTk+Vdyd3d4/jun17jY/+9ksY23Y1bRIKVzsG2HPgWcBVQA7SHW470ys/J5vOXzOT3H1981LVuj766l6t+tpR1uxtDrE5Eos6icnjIzNqAfOecJejz1s6ZM2fO2rVrE/FxGauhuYPP3v0yT23YH5tXkJvFzVfP5x0Lx4dYmYikoIT8/U7nPTZJAyOK87jj+tP53MUnxcaYbOvs4Yu/W8U/3buats7ucAsUkchRsEngsrKMz1w8gztvWERFUW5s/v8+v4Orb13Gyu31IVYnIlGjYJOkOf+kUTz46XM4ZXx5bN5re5q49j+W8+7/XM6+xrYQqxORqMj4c2xmNtBJtGlz5szJ1zm2xGvv6uYHD6/n9qVbj5o/paqYu/oMriwiGUXn2CQ95edk87Ur5/A/Hz6DRVNGxuZvPdDM3/zkKb770Dr2N6mTq4gMTcbvsQ3yeeoVmSS3PrGJHz6y/qh5BblZfPicqXzub04iOysh/0lFJPVpj02i4ZMXTuf7185nRFzHkrbOHv7tiU189NcrOKzxJkXkBCjYJCW86/SJLP3Hi/jK5bNidwoAeOy1fVx2y9NHXQcnIjIYBZukjOL8HD563jSeuvFCLpkzOja/tqGVD/zyeT5/98s0NHeEWKGIpAMFm6Sc4vwc/uPvFvKZN8+IjTcJcO9LO7n4J0/x+5W1tHTo8KSI9C9tO4+Y2RV4AyH3WoR34vGvcfO+5ZxbMsTPV+eRFLBudyNf/v1qVtUeOmp+TpZxwcxR3HD2FBZPq8RMHUxEIiAxnf/SONiuB+44xmI3OOfuHOLnK9hSRHeP445lW/nxoxto7WcIrsvmjuH77ziZ8sLcftYWkTSS2cEWNAVb6tlR38IPHlnPk6/to6lPT8lxFYV84ZKTeNuCcbo8QCR9KdiCpGBLXV3dPSzbXMetj2/i+W1HjzM5pqyAt79pHNcuHM+0USUhVSgiQ6RgC5KCLfX19DhufWITP31sI109b9yOL549mu9fO5/KkvwQqhORIVCwBUnBlj62HWjmX/6ygSWrd78h4EaX5fORc6dy1SljqS4rCKlCETlOCrYgKdjSz4HD7dz/8i5+t2IHr+1pOuq9LIOzp1fxqQunc8bUypAqFJFjULAFScGWvpxz3PnsNr7z0Do6u9+4fV+/eDKfuGCa9uBEUo+CLUgKtvS3va6Z362o5Q8v7WTnwdaj3svJMi6dN4b3nzmJRVNG6jo4kdSgYAuSgi06enocz22t4xv3r2XjvsNveP+8k0bx5ctmMbumVAEnEi4FW5AUbNHT1tnNL5dt5a7l29l16I13655UWcRVp4zl2jeNZ3JVcQgVimQ8BVuQFGzR1dXdw2Ov7eP2pVt5fmt9v8ssmjySDyyezFvmjSFLF3yLJIuCLUgKtuhzzvHwmj3c+uQm1uxs7HeZorxsCnOzGVtRyOmTR/LeMyYwvbo0yZWKZAwFW5AUbJll96FW/rhqF79bUdvvebheWQZXnDyWK+aP4YKZ1RTkZiexSpHIU7AFScGWmZxzrKo9xH89vYUlr+wedNnK4jxuOHsyN5w9heL8nCRVKBJpCrYgKdjk9boWttY1U5SXzau7GvnVs9vYcqD5DcuNKs3nA2dN4oyplSycOELn5ESGTsEWJAWb9NXV3cMja/fy6Kt7eGTtHto6e96wzJyaMt552nhqKgo5dWIF1aW6CFzkBCjYgqRgk8HUN3dw+9It3PbMVtq73hhwvd40sYKPXzCdi2dX6xo5kWNTsAVJwSbHY9fBVu5+YQd/3VrHc1v6v3Sg18jiPE4aXcI506t4/+LJlBXoxqgifSjYgqRgkxO1uvYgdy7bRu3BVmrrW/q9CLxXRVEu1y0cz1vm17BgfIXOy4l4FGxBUrDJcDjnWF17iFv+soEn1u8fdNma8gJOGV/BlFHFXLdwPFN1g1TJXAq2ICnYJFEOtnRQ39zBnsY2nt1Uxx3LttLc0d3vsmZwwUmjmDO2jGc311GYm823rp6nu4FLplCwBUnBJkGpb+5gyepdPPTKHv66tY5+bv59FDO4Yn4NM6pLuebUcUysLEpOoSLJp2ALkoJNkuHA4Xae3VzH9gPN3L9qF5sGGfUEvNvtXHFyDRfOrOak0aVMqizSxeESJQq2ICnYJNl6ehzPbq7jL+v2UtvQwra6lmMGHXgXiJ89rZLL59cwb1w5NeUFurRA0pWCLUgKNkkFz246wK+XbwfgpR0N7G1sP+Y6lcV5nDZ5BKdPHskpEyqYUlVMTpZRkJutsS0l1SnYgqRgk1TT0dXDn1/dy5Pr9/HyjoNsr2+hY5CLw/vKMphdU8Y5M6q4fF4NJ48v156dpBoFW5AUbJLqenocexrbWLXjIH9cvYuXXj/I7kGunetr/IhCzp1RxcSRxSyeVqmgk1SgYAuSgk3SUUNzBy++3sAL2xpYub2e1/Y00dTWdVzrlhXkUFaYy/xx5bxlfg2nTqigsa2TvY1tzBtbTnWZxr2UwCnYgqRgkyhwztHY1oWZN/zXs5vq+NOa3azY3sCJ/q+/cNII/vaMiVxxcg35OTpXJ4FQsAVJwSZRtrexjcfW7WPTvsO8svPgCQVdZXEel84bQ2lBDpNGFnPJ3NFUleQHW7BkCgVbkBRskkkOHG5nR30L+5raeWTtHp7fWk9tQyu52UZ5YR4HDh+7N2Z2lpGdZUwYUcjsmjJm15Qxp6aMcSMKqW1oYWxFIbPGlCXh10gaU7AFScEmma6lo4ucrCxys401Oxu567nt3PfyzkFv03MsF82q5m0LxlJTXsibJlaQk52VwIolAhRsQVKwibxRQ3MHv3+xlvV7mnDA0o0H2NN4/D0x41WV5LNgQgVFedkU5mYzpryAUydWcOqEEZQX6ZY+GUrBFiQFm8ix9fQ49ja10dXt6HGO1s5uNu49zLrdjf6jib1NbSfcUWXaqGIWTBhBXo7R1e1YNGUki6dXMaasgGzd4ifKFGxBUrCJJIZzDufgtyt2cO9LO2lq62LTviY6u0/8b09edhZzx5VxUnUpDkd3jzd+5ujyAmZUl3DG1JGMKsnX9XjpS8EWJAWbSHAamjt4asN+Dhxup62zm8Pt3Wzc28SLrzfQ0NI5rM/Oz8miqiSfypI8ZlSXctLoErp6HFOqirloVrWGFUttCrYgKdhEks85x/a6Fl7a0cCanY3kZBtNbV08+dq+Qe9IfrzKC3P5mzmjmVFdQn1LB6NK8pleXcL06hLGlhfqTubhU7AFScEmklpaOrrYvK+ZFdvr2dfUTrYZWVlGe1c3OxtaWbm94YSGFOurKC+b6dUlnDZpJAW5WexoaGX+uDLevWgiZQW5rNpxkKc27GdnQys1FQW894yJVJdqNJYEU7AFScEmkl6cc9Q1d1B3uIO6w+3sOtTG6tqD7DrYRmd3D89vrae1s/87lw+mIDeLorwc6ps7jppflJfN+86cxDsWjic/J5vOnh66exyd3T20dXbT3tXD9FElGorsxCjYgqRgE4mWprZOnli/n6fW7+dQaycji3PZdbCNTfsOD/mSheNRU17AyePLyc4yenrgrGmV/uDTRbqO740UbEFSsIlkjqa2Tjbvb+aV2oP8dWs9Pc5hZjyzYT+NcYNInzqxgokji3h6w/5hd3LJzTYmjixienUJM0eXkpeTxf6mdjbuO0xudhZTqoqZOqrYfy6hpqwgE84BKtiCpGATkbbObl7d3cj2umamVJVwin9rn6a2Tu5+YQd3PbedbXUtgBdUOVlZ5GR7N3V1juMaiux45edkMbaikNxsY3RZAVOqimlu72ZkcS5vWzCOSZVF5GRlUZiXTXtXNy3t3VQU5abbpQ8KtiAp2ETkeHR195CdZf0GyN7GNl7ecZB1uxvJzc7iUGsnj63by5YDzSd80frxGlWaz8GWDjq7HbPGlHLO9Cryc7OYNaaMUydW4Bx0dHvDolUW51Fe6IXflv3eIdlZY8oYWZwXTHHHpmALkoJNRILS1tnNtrpmtuxvZsPeJjbvb8aA0oIcZlR7191t3t/M1gOH2Xqgmb2Nidvz62tEUS652VnsazryHZMqi1gwoYIFEyqoLMmnub0LA0oKcphcWcyY8gIOHG5n6cYDFOfn8ObZ1YnqIapgC5KCTURSxeH2LrYdaGZ/Uzud3T1sr2th58FWcrKMF7bVs6r2UKj1mcHY8kKmVBVz1rRKPnnh9CF/VCLqyUnEh4iISHBK8nOYN658wPcPtnTQ46C1s5vtdc2UF+aSnWU8uGo3exvbaOvq4bktdez398pys40eB909R+/YlOTncLj9+O64Hs852HmwlZ0HWynOD39kFwWbiEiaqyg6ck5sXEVh7HX8/e+cc3R2O3KzvfOBvdf9Pb+1nu11LZw8vpzF0yqpbWjl5R0HeXnHQV6pPUR7VzfF+Tk4B/XNHWyvb6at0ztHd/L4cuoOd7DzYGvseyZXFifhFw9OhyIHoEORIiJv5JyjpaObHucoLcilp8exvb6FbXXNbD/QzLxx5Zw2eeRQP16HIkVEJLnMjOL8I9GRlWVMqfKut2NmiIXF0WXvIiISKQo2ERGJFAWbiIhEioJNREQiRcEmIiKRomATEZFI0XVsAzCzxvz8/NJp06aFXYqISEZ49dVX/+icu2q4n6NgG4CZ7QGKgB0nuGpvEm5ObEUZQ+03PGq/oVPbDU8i2m+zgi0FmdlaAOfc3LBrSUdqv+FR+w2d2m54Uqn9dI5NREQiRcEmIiKRomATEZFIUbCJiEikKNhERCRS1CtSREQiRXtsIiISKQo2ERGJFAWbiIhEioJNREQiRcEmIiKRomATEZFIUbCJiEikKNgSxMwKzeybZrbBzNrMbJeZ/dLMxoVdWyowsyfNzA3yuGyA9a43s+fN7LCZ1ZvZQ2a2ONn1J4OZLTSzL5vZvWZW29s2x7HeCbeRmZ3tL1fvr/e8mb0/cb8m+U60/czspmNsk98bZN1ItZ+ZFZnZ1WZ2u5mt9/+GNZvZKjP7upmVDLJu6m1/zjk9hvkACoDlgAN2AXcDf/Wn9wFTw64x7AfwpN8e9wB39vOY3886t/jrtAD3AQ8DnUAXcHXYvymANrrP/71HPY6xzgm3EXCt/36P/9/lHqDB/5wfhd0OyWo/4CZ/maUDbJPXZUr7AR+Oa7NXgd/621KjP28dUJ0u21/oDRqFB3Cz/x/lWaAkbv7n/flPhl1j2A+OBNvk41z+Yn/5A8CMuPlnAe3+/wgVYf+uBLfRPwLfBN4KjAHajvGH+YTbCBgJHPLXe3vc/NHARn/+BWG3RZLarzfYrj+B74hk+wEfAH4BzO4zvwZ40f9dv0mX7S/0Bk33B5AHHPT/g5zaz/ur/PcWhl1ryO10osH2kL/8Z/t576f+e18I+3cF3GbH+sN8wm0EfMmff18/61zjv/fHsH97ktpvKMGWMe0X97vO8n9XG5AXNz9ltz+dYxu+s4FyvFuav9TP+/f4z29NXknpzcwKgYv8yXv6WSTj23QYbXTFIOsswfvjdbGZFQy7yGjKxPZb5T/nA5WQ+ttfznBWFgBO8Z9fHOD93vknJ6GWdPAhM6vEO76+Ae9fbq/3WWYm3v9E+51ztf18htp06G004PbqnOswszXAacBJwOoE1ZrqLjKzBXjnymuBPznnVg6wbCa231T/uROo91+n9PanPbbhm+g/9/cfN37+pCTUkg7+H/Bx4JN4hys2mdnX+iwzaJs655rxDv+OMLPSgOpMdSfcRmZWhnd0YcD1yMzt9X3AZ4CPAd8CVpjZPX17AmZw+33Gf37YOdfuv07p7U/BNny9G3/LAO83+8+Z+ge419N4f0CmAUV4/+L7Kl7vqG+a2Wfilj1Wm4LadShtFP+HWtsrbAK+CMzFa5sJwN8CO/F67v13n+Uzrv3M7HLgQ3h7a/H/AE3p7U+HIiUpnHNf7zNrA/AdM1sBPALcZGb/6ZxrTX51komcc3f1mdUM/MbMngBeAa42szOdc88lv7rwmdks4C7AgBudc6uOsUrK0B7b8B32n4sGeL/Yf25KQi1pxzn3KLACqADO8Gcfq01B7TqUNjoc95621wE453YDd/iT8QMHZEz7+QNLPAyMAH7inPtpn0VSevtTsA1fb8eH8QO83zt/exJqSVcb/eca/3nQNjWzYrwgbHDOpfUfkGE44TZyzjXiXUM04Hpoe+3Vd5vMmPYzs5HAo3jnue7AO1zbV0pvfwq24evdPX/TAO/3zo9KD6kgjPCfe4+vr8e7wHPUAEOSqU2H3kYDbq9mlgvMw+tyvSFBdaarvttkr0i3n99h5k/AHOBe4CPOv8isj5Te/hRsw7cM718h0/wuw329w3/+Y9IqSiNmNgo41598EcA/z/a4P++6flbL+DYdRhst6fN+vCvxurz/xTnXNuwi05SZGd7FwvDGbumRbT8zywfuBxbhnfd+j3Ouu79lU377C/uq9ig8ODKk1jKgOG6+htTy2mExcDWQ3Wf+ZLxx+hxwf5/3Bhuup40IDqnVT7sNZ0itftuIgYc0qiaNh4Q60fYDRuFdclLaZ34J8HO/HXYDRZnQfkA23h6aw+vBXHQc66Ts9hd6g0bhgfevjOc4ehDk3umMHwQZuD7uD8US4H/8QGv1569h8AFWm/EGWH2IaA+CfIW/3fQ+evzfHz/viuG2EV5X9m7/8x8HfseRQWh/HHY7JKP98P5R5fA6KTzub5OP+n+knd8eZ2dK++Fdq+b8x730Pyj0nUBVOmx/oTdoVB5AId4ArJvwjj339qwaH3ZtYT+A2cC/Ayvxgr4T7+LN5Xh7tYWDrHs9Xq/JZn/j/xOwOOzfFFA7XR/3x2Wgx/WJaCO8oeD+5C/fDLwAfCDsNkhW++FdJ/U9vDFMa/H2MJrx/pH1I2BcJrUfR8bNPNZjcjpsf+Z/iYiISCSo84iIiESKgk1ERCJFwSYiIpGiYBMRkUhRsImISKQo2EREJFIUbCIiEikKNhERiRQFm4iIRIqCTUREIkXBJiIikaJgEwmQmbnjeNwZdp3HYmY3+bVeH3YtIseSE3YBIhniV4O8tzRpVYhkAAWbSBI4564PuwaRTKFDkSIiEikKNpEU45/L2mZmeWb2z2a22czazGyLmX3TzAoGWK/SzH5oZhv95evN7GEzu2SQ76o0s2+b2Stm1mxmjf7rH5hZzQDrzDezB8yswV/nKTNbnKjfLzJcCjaR1GTA74EbgVeBJcBI4GvAg2aWfdTCZuOA54EvAnnAfcBLwMXAI2b2uTd8gdls4GXgK0AV8AjwF/+7bwTO6Keu04DngMn+8huB84DHzGze0H+uSOLoHJtIapqI9w/Pec65LQBmNgp4HHgz8Gnglrjlfw5MBX4D3OCc6/DXOQcvgH5oZk8451725+cAfwDG+5/zj73r+O/PBdr6qeuTwGecc/8at+y/AJ8FvgS8f3g/W2T4tMcmkgTH6O5/9QCrfbM31ACcc/vx9qQAPhX32VOBK4HDwKfjA8o5txQv9LLxQqnX24GZwFrgi/Hr+Outdc5t7qemZfGh5rvZfz5vgN8hklTaYxNJjsG6+78+wPz/6zvDOfewmTUA08ysxjm3GzjHf/th51x9P5/z38DngXPj5l3sP9/mnOsevPSjPNpPTXVmVg/0e05OJNkUbCJJMITu/g3OuaYB3tsOjADGArv9Z4BtAyzfO39c3LwJ/nN/e2WDqR1gfhPeOUCR0OlQpEj0uQR+Vk8CP0skEAo2kdQ0wsxKB3hvov+8q8/zpAGWn+w/74ybt8N/njak6kRSmIJNJHW9s+8M/5q0kcAW//waHBmS6zIzq+jnc/7Of34mbt5f/OcPmZn+DkikaIMWSV3fMLPJvRNmVgX80J+8tXe+33NyCVAK/NTMcuPWOQv4ONAdvw5wL7ABmAf8IH4df725fm9LkbSjziMiSXCMEfxfd859ve88YDWw1sweAzqBi4AK4Amgb5f7j+Htkb0fON/MlgOjgAvwuvp/ofcaNgDnXJeZXQv8GfgC8F5/HQNm4AXeNcAWRNKMgk0kOT4wyHurgL7B5oB3+PPfy5EekLcC33bOdR21sHM7zex04J+Aq/GuU2sBHgN+7Jzrr5v+GjM7Be/auKuAy4F2vFD9Pt4IIyJpx5xLZIcpERkuM3PAdufc5LBrEUlHOscmIiKRomATEZFIUbCJiEik6BybiIhEivbYREQkUhRsIiISKQo2ERGJFAWbiIhEioJNREQiRcEmIiKRomATEZFIUbCJiEikKNhERCRSFGwiIhIpCjYREYkUBZuIiESKgk1ERCJFwSYiIpHy/wFyGQySJDmR+wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 450x300 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 200: loss=0.23569\n"
     ]
    }
   ],
   "source": [
    "loss_hist = train(x_train, y_train, lr=2e-4, nb_epochs=nb_epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training accuracy: 0.982\n",
      "Test accuracy: 0.692\n"
     ]
    }
   ],
   "source": [
    "print(\"Training accuracy: %.3f\"%(compute_classification_accuracy(x_train,y_train)))\n",
    "print(\"Test accuracy: %.3f\"%(compute_classification_accuracy(x_test,y_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_mini_batch(x_data, y_data, shuffle=False):\n",
    "    for ret in sparse_data_generator_from_hdf5_spikes(x_data, y_data, batch_size, nb_steps, nb_inputs, max_time, shuffle=shuffle):\n",
    "        return ret "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_batch, y_batch = get_mini_batch(x_test, y_test)\n",
    "output, other_recordings = run_snn(x_batch.to_dense())\n",
    "mem_rec, spk_rec = other_recordings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig=plt.figure(dpi=100)\n",
    "plot_voltage_traces(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1050x450 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's plot the hiddden layer spiking activity for some input stimuli\n",
    "\n",
    "nb_plt = 4\n",
    "gs = GridSpec(1,nb_plt)\n",
    "fig= plt.figure(figsize=(7,3),dpi=150)\n",
    "for i in range(nb_plt):\n",
    "    plt.subplot(gs[i])\n",
    "    plt.imshow(spk_rec[i].detach().cpu().numpy().T,cmap=plt.cm.gray_r, origin=\"lower\" )\n",
    "    if i==0:\n",
    "        plt.xlabel(\"Time\")\n",
    "        plt.ylabel(\"Units\")\n",
    "\n",
    "    sns.despine()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that spiking in the hidden layer is quite sparse as in the previous Tutorial 3 because we used the same activity regularizer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/88x31.png\" /></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Creative Commons Attribution 4.0 International License</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
